home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 June / MacFormat 25.iso / Shareware City / Developers / macgzip_03b2-src / macos / think / ThePrefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-07  |  21.7 KB  |  775 lines  |  [TEXT/KAHL]
  1. /*            SpinCursors by
  2.  *            America Online: LISPer
  3.  *             Internet: tree@uvm.edu
  4.  */
  5. #ifndef _FOLDERS_
  6. #include <Folders.h>
  7. #endif
  8. #include <Script.h>
  9. #include <Balloons.h>
  10.  
  11. #include <ICAPI.h>
  12. #include <ICKeys.h>
  13.  
  14. #include "ThePrefs.h"
  15. #include "MacErrors.h"
  16. #include "PopUp.h"
  17.  
  18.  
  19. /************************************************************************************/
  20.  
  21. #define kPrefsDialogID        130
  22. #define kSaveButtonItem        1
  23. #define kCancelButtonItem    2
  24.  
  25. #define    kKeepOrig            16
  26. #define kBeepWD                14
  27. #define kQuitWD                5
  28.  
  29. #define kForce                7
  30. #define    kBHelp                8
  31. #define kHelp                15
  32.  
  33. #define kCStKeys            26
  34. #define kUStKeys            27
  35. #define    kAltStKeys            30
  36.  
  37. #define kTEXTsuffix            3
  38. #define kTEXTcreator        4
  39. #define kTEXTbcreator        23
  40. #define kTEXTbtype            28
  41.  
  42. #define kTEXTlevel            10
  43.  
  44. #define kUpArrow            11
  45. #define kDownArrow            12
  46.  
  47. #define    kAsciiGzip            17
  48. #define    kAsciiGunzip        18
  49. #define    kGzip                19
  50.  
  51.  
  52. #define    kAsciiGzipMenu        128
  53. #define    kAsciiGunzipMenu    129
  54. #define    kGzipMenu            130
  55.  
  56. /* prefs file constants */
  57. #define kPrefsNameStrID            128
  58. #define kPrefsCreatorType        '\?\?\?\?'
  59. #define kPrefsFileType            'pref'
  60. #define kPrefsResourceType        'Pref'
  61. #define kPrefsResourceID        128
  62.  
  63. #define kFetchPrefsNameStrID    129
  64. #define kFetchPrefsResourceType    'SUFX'
  65. #define kFetchPrefsResourceID    1
  66.  
  67. #define kFinderMessageStrID    -16397 /* ID of STR for default finder message */
  68.                                    /* see Inside Mac VI, page 9-22         */
  69. #define kStrType            'STR '
  70.  
  71. #define CmdKeyMask            0x0100
  72.  
  73. /*
  74.  * From DialogBits,C.K. Haun
  75.  * Apple Developer Tech Support
  76.  */
  77.  
  78.  /* key equates */
  79. enum  {
  80.     kEnterKey        = 0x03, 
  81.     kTabKey            = 9, 
  82.     kReturnKey        = 0x0D, 
  83.     kBackSpace        = 8, 
  84.     kEscKey            = 0x1B, 
  85.     kLeftArrowKey    = 0x1C, 
  86.     kRightArrowKey, 
  87.     kUpArrowKey,
  88.     kDownArrowKey, 
  89.     kDeleteKey        = 0x7F
  90. };
  91.  
  92. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem);
  93.  
  94. pascal OSErr GetStdFilterProc(ModalFilterProcPtr *theProc) = 
  95. {
  96.     0x303C, 0x0203, 0xAA68
  97. };
  98.  
  99. /* Indicates to the dialog manager which item is default.  Will then alias the return key */
  100. /* to this item, and also bold border it for you (yaaaaa!) */
  101. pascal OSErr SetDialogDefaultItem(DialogPtr theDialog, short newItem)
  102. = 
  103. {
  104.     0x303C, 0x0304, 0xAA68
  105. };
  106.  
  107. /* Indicates which item should be aliased to escape or Command - . */
  108. pascal OSErr SetDialogCancelItem(DialogPtr theDialog, short newItem)
  109. = 
  110. {
  111.     0x303C, 0x0305, 0xAA68
  112. };
  113. /* End From DialogBits */
  114.  
  115. /* these constants may be stored in the fields of the prefs struct */
  116.  
  117. static OSErr GetPrefsName (StringPtr prefName, short StrID);
  118. static ICError ICGetPrefHandle (ICInstance inst, ConstStr255Param key, 
  119.                          ICAttr *attr, Handle *prefh);
  120.                          
  121. PrefsType    currPrefs;
  122. Boolean        prefsChangedFlag;
  123.  
  124. Handle        FPrefs;
  125. Size        FPrefsSize=0;
  126.  
  127. ICInstance    inst;
  128. Handle        ICmappings = nil;
  129.  
  130.  
  131. short OpenPrefsResFile(SignedByte prefsPerm, Boolean createFlag, short StrID)
  132. /* open the preferences file with the given permission; if createFlag is set,
  133.    create a preferences file if necessary */
  134. {
  135.     OSErr retCode;
  136.     short prefsVRefNum;
  137.     long prefsDirID;
  138.     Str255 prefsNameStr;
  139.     FSSpec prefsFSSpec;
  140.     short prefsResRefNum;
  141.     
  142.     prefsResRefNum = -1;
  143.     /* get the name of the prefs file */
  144.     retCode = GetPrefsName(prefsNameStr, StrID);
  145.     if (retCode == noErr) {
  146.     
  147.         /* Use FindFolder to locate the Preferences folder.
  148.         
  149.            MPW 3.2 and some other compilers provide the
  150.            glue necessary to use FindFolder (and Gestalt) safely
  151.            under System 6 and earlier.  Under System 6, the dirID
  152.            returned for the Preferences folder request will be
  153.            the System folder's dirID */
  154.  
  155.         retCode = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  156.             &prefsVRefNum, &prefsDirID);
  157.         if (retCode == noErr) {
  158.         
  159.             /* make a file spec for the prefs file */
  160.             
  161.             retCode = FSMakeFSSpec(prefsVRefNum, prefsDirID, prefsNameStr,
  162.                 &prefsFSSpec);
  163.                 
  164.             if (retCode == fnfErr && createFlag) {
  165.                 /* prefs file doesn't already exist, so create it */
  166.                 FSpCreateResFile(&prefsFSSpec, kPrefsCreatorType, kPrefsFileType,
  167.                     smSystemScript);
  168.                 retCode = ResError();
  169.             }
  170.             
  171.             /* open the prefs file */
  172.             if (retCode == noErr) {
  173.                 prefsResRefNum = FSpOpenResFile(&prefsFSSpec, prefsPerm);
  174.             }
  175.         }
  176.     }
  177.     return prefsResRefNum;
  178. }
  179.  
  180. static OSErr GetPrefsName (StringPtr prefName, short StrID)
  181. /* get the name of the preferences file from a resource in the application */
  182. {
  183.     StringHandle prefStrHandle;
  184.     OSErr retCode = noErr;
  185.     
  186.     prefStrHandle = GetString(StrID);
  187.     if (prefStrHandle != nil) 
  188.         BlockMove(*prefStrHandle, prefName, (Size) (**prefStrHandle) + 1);
  189.     else retCode = resNotFound;
  190.     
  191.     return retCode;
  192. }
  193.  
  194. Boolean GetOrGeneratePrefs( PrefsType * thePrefsTypePtr, long wantedVers )
  195. /* fill in the prefs structure from the resource file or from scratch */
  196. {
  197.     short                prefsResRefNum;
  198.     Handle                tempHandle;
  199.     extern    Boolean        gSavedPos;
  200.     extern    Point        gSavedPoint;
  201.     
  202.     /* initialize prefs structure in case we can't get a valid set */
  203.     thePrefsTypePtr->prefsTypeVers =        wantedVers;
  204.     thePrefsTypePtr->compress =                false;
  205.     thePrefsTypePtr->ascii =                false;
  206.     thePrefsTypePtr->force =                false;
  207.     thePrefsTypePtr->level =                6;
  208.     thePrefsTypePtr->suffix[0] =            0x00;
  209.     BlockMove("\pttxt", thePrefsTypePtr->textcreator, 5);
  210.     BlockMove("\p\?\?\?\?", thePrefsTypePtr->bincreator, 5);
  211.     BlockMove("\p\?\?\?\?", thePrefsTypePtr->bintype, 5);
  212.     thePrefsTypePtr->KeepOriginals =        false;
  213.     thePrefsTypePtr->QuitWhenDone =            true;
  214.     thePrefsTypePtr->BeepWhenDone =            false;
  215.  
  216.     thePrefsTypePtr->AsciiCompress =        OnlyText;
  217.     thePrefsTypePtr->AsciiUnCompress =        UseMenu;
  218.     thePrefsTypePtr->ResourceCompress =        Ask;
  219.     thePrefsTypePtr->WhenCompress =            NonMacGzip;
  220.  
  221.     thePrefsTypePtr->DecodeHQX =    false;
  222.     thePrefsTypePtr->StKeysComp =    true;
  223.     thePrefsTypePtr->StKeysUnComp =    true;
  224.     thePrefsTypePtr->StKeysAlt =     true;
  225.  
  226.     thePrefsTypePtr->SavedPos = false;
  227.     thePrefsTypePtr->SavedPoint.h = 0;
  228.     thePrefsTypePtr->SavedPoint.v = 0;
  229.     
  230.     
  231.     /* open (but don't create) the prefs file */
  232.     prefsResRefNum = OpenPrefsResFile(fsRdPerm, false, kPrefsNameStrID);
  233.     if (prefsResRefNum != -1) {
  234.     
  235.         /* file opened successfully, get the prefs resource */
  236.         tempHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  237.         
  238.         /* if the resource is there and it's the right size and version, copy it */
  239.         /* (in C these can be combined with &&, but don't use AND in Pascal)     */
  240.         
  241.         if (tempHandle != nil)
  242.             if (GetHandleSize(tempHandle) == sizeof(PrefsType)) 
  243.                 if ((*(PrefsType *)*tempHandle).prefsTypeVers == wantedVers) {
  244.                 
  245.                     /* copy the prefs struct */
  246.                     *thePrefsTypePtr = *(PrefsType *)*tempHandle;
  247.                     
  248.                 }
  249.         /* release the pref resource and close the file */
  250.         CloseResFile(prefsResRefNum);
  251.         
  252.     /*
  253.      * Get Fetch Prefs
  254.      */
  255.      
  256.     if( thePrefsTypePtr->AsciiUnCompress == Fetch )
  257.     {
  258.     if((prefsResRefNum = OpenPrefsResFile(fsRdPerm, false, kFetchPrefsNameStrID))!=-1)
  259.         {
  260.             tempHandle = GetResource('SUFX',1);
  261.             FPrefs = tempHandle;
  262.             HandToHand( &FPrefs );
  263.             FPrefsSize = GetHandleSize(FPrefs);
  264.             ReleaseResource( tempHandle );
  265.             CloseResFile(prefsResRefNum);
  266.         }
  267.         else
  268.         {
  269.             /* Fetch Prefs not found; set to menu */
  270.             Calert("Warning: 'Fetch Prefs' not found. Check your Prefs. folder");
  271.             thePrefsTypePtr->AsciiUnCompress = UseMenu;
  272.         }
  273.     }
  274.     /*
  275.      * Get Internet Config Prefs
  276.      */
  277.     else if (
  278.         ( thePrefsTypePtr->AsciiUnCompress == UseICinExp ) ||
  279.         ( thePrefsTypePtr->AsciiCompress == UseICinComp ) )
  280.     {
  281.         Boolean ICErr = true;
  282.         
  283.         if (!ICStart(&inst, 'ICMa'))
  284.         {                                                // init the sucker
  285.             if (!ICFindConfigFile(inst, 0, nil))
  286.             {                                            // locate the config file
  287.                 if (!ICBegin(inst, icReadOnlyPerm))
  288.                 {                                        // open up the file for reading
  289.                     ICAttr    attr = 0;
  290.                     
  291.                     ICErr = false;
  292.                     
  293.                     if (!ICGetPrefHandle(inst, (ConstStr255Param)kICMapping, &attr, &ICmappings))
  294.                     {
  295.                         HUnlock(ICmappings);
  296.                     }
  297.                     else
  298.                     {
  299.                         /* Can't get ICmappings */
  300.                         ICmappings = nil;
  301.                         Calert("Warning: Can't get Mappings from IC. Check your IC Prefs");
  302.                         thePrefsTypePtr->AsciiUnCompress = UseMenu;
  303.                     }
  304.                     ICEnd(inst);                            // all done
  305.                 }
  306.                 
  307.             }
  308.             ICStop(inst);
  309.         }
  310.         
  311.         
  312.         if(ICErr)
  313.         {
  314.             ICmappings = nil;
  315.             Calert("Warning: IC Prefs not found. Check your Internet Prefs");
  316.             thePrefsTypePtr->AsciiUnCompress = UseMenu;
  317.         }
  318.     }
  319.     
  320.         gSavedPos = thePrefsTypePtr->SavedPos;
  321.         gSavedPoint.h = thePrefsTypePtr->SavedPoint.h;
  322.         gSavedPoint.v = thePrefsTypePtr->SavedPoint.v;
  323.  
  324.     return true;
  325.     
  326.     }
  327.     else
  328.         return false;
  329. }
  330.  
  331.  
  332.  
  333.  
  334.  
  335. OSErr SavePrefs(PrefsType * thePrefsTypePtr )
  336. /* save the prefs structure in the prefs resource file */
  337. {
  338.     OSErr retCode;
  339.     short prefsResRefNum;
  340.     Handle prefHandle, finderMessageHandle;
  341.     
  342.     /* open (and, if necessary, create) the prefs file */
  343.     prefsResRefNum = OpenPrefsResFile(fsRdWrPerm, true, kPrefsNameStrID);
  344.     if (prefsResRefNum != -1) {
  345.     
  346.         /* file opened successfully, get the prefs resource */
  347.         prefHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  348.         
  349.         if (prefHandle == nil) {
  350.         
  351.             /* create a new resource */
  352.             prefHandle = NewHandle(sizeof(PrefsType));
  353.             if (prefHandle != nil) {
  354.             
  355.                 /* copy the prefs struct into the handle
  356.                    and make it into a resource */
  357.                 
  358.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  359.                 AddResource(prefHandle, kPrefsResourceType, kPrefsResourceID, 
  360.                     "\pPrefsType");
  361.                 retCode = ResError();
  362.                 if (retCode != noErr) DisposHandle(prefHandle);
  363.             } 
  364.             
  365.             else retCode = MemError(); /* NewHandle failed */
  366.         }
  367.         
  368.         else {  /* prefHandle != nil */
  369.         
  370.             /* update the existing resource */
  371.             SetHandleSize(prefHandle, sizeof(PrefsType));
  372.             retCode = MemError();
  373.             if (retCode == noErr) {
  374.  
  375.                 /* copy the prefs struct into the handle and tell the rsrc manager */
  376.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  377.                 ChangedResource(prefHandle);
  378.             }
  379.         }
  380.         if (retCode == noErr) {
  381.         
  382.             /* add the message to be displayed if the user tries
  383.                to open the prefs file in the Finder (but don't add it
  384.                if it's already in the preferences file) */
  385.                
  386.             finderMessageHandle = (Handle) GetString(kFinderMessageStrID);
  387.             if (finderMessageHandle != nil &&
  388.                 HomeResFile((Handle) finderMessageHandle) != prefsResRefNum) {
  389.             
  390.                 /* copy the resource into the prefs file */
  391.                 DetachResource(finderMessageHandle);
  392.                 AddResource(finderMessageHandle, kStrType, kFinderMessageStrID,
  393.                     "\pFinder message");
  394.                     
  395.                 /* if AddResource failed, dispose of the handle */
  396.                 retCode = ResError();
  397.                 if (retCode != noErr) DisposHandle(finderMessageHandle);
  398.             }
  399.         }
  400.         
  401.         /* update and close the preference resource file, 
  402.            releasing its resources from memory */
  403.         CloseResFile(prefsResRefNum);
  404.     }
  405.     
  406.     else {
  407.         /* couldn't open the res file */
  408.         retCode = ResError();
  409.         if (retCode == noErr) retCode = resFNotFound;
  410.     }
  411.     
  412.     return retCode;
  413. }
  414.  
  415.  
  416.  
  417. /***********************Dialog*************/
  418. Boolean DoPrefsDialog(PrefsType * thePrefsTypePtr)
  419. /* display the prefs dialog; returns true if change made to prefs record */
  420. {
  421.     GrafPtr savePort;
  422.     DialogPtr prefDialogPtr;
  423.     short item;
  424.     Boolean doneFlag = false;
  425.     Boolean    SaveBalloons;
  426.     OSErr retCode;
  427.  
  428.     /* keep the new preference settings only in local variables
  429.        in case the user cancels */
  430.        
  431.     PrefsType newPrefsType;
  432.  
  433.     short        itemType;
  434.     Handle        itemHandle;
  435.     Rect        itemRect;
  436.     Str255        sTemp;
  437.     
  438.     Boolean changedFlag;
  439.  
  440.  
  441.     /* the old settings are our starting point, so copy them */
  442.     newPrefsType = *thePrefsTypePtr;
  443.     
  444.     /* throw up the dialog */
  445.     prefDialogPtr = GetNewDialog(kPrefsDialogID, nil, (WindowPtr) -1);
  446.     if (prefDialogPtr == nil) ExitToShell();  /* hurtin’ bad */
  447.     
  448.     SetDialogDefaultItem( prefDialogPtr, kSaveButtonItem);
  449.     SetDialogCancelItem( prefDialogPtr, kCancelButtonItem);
  450.  
  451.     /* set up the dialog to the initial values */
  452.     SaveBalloons = HMGetBalloons();
  453.  
  454.     GetDItem(prefDialogPtr, kForce, &itemType, &itemHandle, &itemRect);
  455.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.force ? 1 : 0));
  456.  
  457.     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  458.     NumToString( (long)thePrefsTypePtr->level, sTemp );
  459.     SetIText(itemHandle,sTemp);
  460.  
  461.  
  462.  
  463.     GetDItem(prefDialogPtr, kTEXTsuffix, &itemType, &itemHandle, &itemRect);
  464.     SetIText(itemHandle,thePrefsTypePtr->suffix);
  465.  
  466.     
  467.     
  468.     GetDItem(prefDialogPtr, kTEXTcreator, &itemType, &itemHandle, &itemRect);
  469.     SetIText(itemHandle,thePrefsTypePtr->textcreator);
  470.     
  471.     GetDItem(prefDialogPtr, kTEXTbcreator, &itemType, &itemHandle, &itemRect);
  472.     SetIText(itemHandle,thePrefsTypePtr->bincreator);
  473.  
  474.     GetDItem(prefDialogPtr, kTEXTbtype, &itemType, &itemHandle, &itemRect);
  475.     SetIText(itemHandle,thePrefsTypePtr->bintype);
  476.  
  477.     SelIText(prefDialogPtr, kTEXTbcreator, 0, 32767);
  478.  
  479.     GetDItem(prefDialogPtr, kKeepOrig, &itemType, &itemHandle, &itemRect);
  480.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.KeepOriginals ? 1 : 0));
  481.  
  482.     GetDItem(prefDialogPtr, kBeepWD, &itemType, &itemHandle, &itemRect);
  483.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.BeepWhenDone ? 1 : 0));
  484.  
  485.     GetDItem(prefDialogPtr, kQuitWD, &itemType, &itemHandle, &itemRect);
  486.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.QuitWhenDone ? 1 : 0));
  487.  
  488.  
  489.     GetDItem(prefDialogPtr, kAsciiGzip, &itemType, &itemHandle, &itemRect);
  490.     PopUp[kAsciiGzip-PopUpBaseItem].MenuRect = itemRect;
  491.     PopUp[kAsciiGzip-PopUpBaseItem].MenuID = kAsciiGzipMenu;
  492.     PopUp[kAsciiGzip-PopUpBaseItem].Menu = GetMenu(kAsciiGzipMenu);
  493.     PopUp[kAsciiGzip-PopUpBaseItem].Selection = newPrefsType.AsciiCompress;
  494.     SetItemMark(PopUp[kAsciiGzip-PopUpBaseItem].Menu,PopUp[kAsciiGzip-PopUpBaseItem].Selection,checkMark);
  495.     SetDItem(prefDialogPtr, kAsciiGzip, itemType, (ProcPtr) &DrawPopUp, &itemRect);
  496.  
  497. /*    WARNING!
  498.  *    SetDialogItem( prefDialogPtr, kAsciiGzip,
  499.  *                itemType, UserItemUPP((ProcPtr) &DrawPopUp), &itemRect); for PPC ?
  500.  */
  501.     GetDItem(prefDialogPtr, kAsciiGunzip, &itemType, &itemHandle, &itemRect);
  502.     PopUp[kAsciiGunzip-PopUpBaseItem].MenuRect = itemRect;
  503.     PopUp[kAsciiGunzip-PopUpBaseItem].MenuID = kAsciiGunzipMenu;
  504.     PopUp[kAsciiGunzip-PopUpBaseItem].Menu = GetMenu(kAsciiGunzipMenu);
  505.     PopUp[kAsciiGunzip-PopUpBaseItem].Selection = newPrefsType.AsciiUnCompress;
  506.     SetItemMark(PopUp[kAsciiGunzip-PopUpBaseItem].Menu,PopUp[kAsciiGunzip-PopUpBaseItem].Selection,checkMark);
  507.     SetDItem(prefDialogPtr, kAsciiGunzip, itemType, (ProcPtr) &DrawPopUp, &itemRect);
  508.  
  509.     GetDItem(prefDialogPtr, kGzip, &itemType, &itemHandle, &itemRect);
  510.     PopUp[kGzip-PopUpBaseItem].MenuRect = itemRect;
  511.     PopUp[kGzip-PopUpBaseItem].MenuID = kGzipMenu;
  512.     PopUp[kGzip-PopUpBaseItem].Menu = GetMenu(kGzipMenu);
  513.     PopUp[kGzip-PopUpBaseItem].Selection = newPrefsType.WhenCompress;
  514.     SetItemMark(PopUp[kGzip-PopUpBaseItem].Menu,PopUp[kGzip-PopUpBaseItem].Selection,checkMark);
  515.     SetDItem(prefDialogPtr, kGzip, itemType, (ProcPtr) &DrawPopUp, &itemRect);
  516.  
  517.     GetDItem(prefDialogPtr, kCStKeys, &itemType, &itemHandle, &itemRect);
  518.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysComp ? 1 : 0));
  519.     
  520.     GetDItem(prefDialogPtr, kUStKeys, &itemType, &itemHandle, &itemRect);
  521.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysUnComp ? 1 : 0));
  522.     
  523.     GetDItem(prefDialogPtr, kAltStKeys, &itemType, &itemHandle, &itemRect);
  524.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysAlt ? 1 : 0));
  525.  
  526.     GetDItem(prefDialogPtr, kHelp, &itemType, &itemHandle, &itemRect);
  527.     SetCtlValue((ControlHandle) itemHandle, SaveBalloons);
  528.  
  529.     do {
  530.         GetPort(&savePort);
  531.         SetPort(prefDialogPtr);
  532.  
  533.         ModalDialog((ModalFilterProcPtr)filterIt, &item);
  534.         switch(item) {
  535.         
  536.             
  537.             case kSaveButtonItem:
  538.                 /* user wants to save the current or new settings */
  539.                 
  540.                 /* copy the editText string into the new prefs record */
  541.                 GetDItem(prefDialogPtr, kTEXTcreator, &itemType, &itemHandle, &itemRect);
  542.                 GetIText(itemHandle, newPrefsType.textcreator);
  543.                 
  544.                 GetDItem(prefDialogPtr, kTEXTbcreator, &itemType, &itemHandle, &itemRect);
  545.                 GetIText(itemHandle, newPrefsType.bincreator);
  546.                 
  547.                 GetDItem(prefDialogPtr, kTEXTbtype, &itemType, &itemHandle, &itemRect);
  548.                 GetIText(itemHandle, newPrefsType.bintype);
  549.  
  550.                 GetDItem(prefDialogPtr, kTEXTsuffix, &itemType, &itemHandle, &itemRect);
  551.                 GetIText(itemHandle, newPrefsType.suffix);
  552.                 
  553.                 if(newPrefsType.textcreator[0]!=0x04)
  554.                 {
  555.                     Calert( "Text creator not valid (Only 4 chars!)" );
  556.                     SelIText(prefDialogPtr, kTEXTcreator, 0, 32767);
  557.                 }
  558.                 else if (newPrefsType.bincreator[0]!=0x04)
  559.                 {
  560.                     Calert( "Binary creator not valid (Only 4 chars!)" );
  561.                     SelIText(prefDialogPtr, kTEXTbcreator, 0, 32767);
  562.                 }
  563.                 else if (newPrefsType.bintype[0]!=0x04)
  564.                 {
  565.                     Calert( "Binary type not valid (Only 4 chars!)" );
  566.                     SelIText(prefDialogPtr, kTEXTbtype, 0, 32767);
  567.                 }
  568.                 else
  569.                 {
  570.                         /* replace the old record with the new record */
  571.                         
  572.                         newPrefsType.AsciiCompress = PopUp[kAsciiGzip-PopUpBaseItem].Selection;
  573.                         newPrefsType.AsciiUnCompress = PopUp[kAsciiGunzip-PopUpBaseItem].Selection;
  574.                         newPrefsType.WhenCompress = PopUp[kGzip-PopUpBaseItem].Selection;
  575.                         
  576.                         *thePrefsTypePtr = newPrefsType;
  577.                         doneFlag = true;
  578.                 }
  579.                 
  580.                 if (
  581.                     (( FPrefsSize==0) && (newPrefsType.AsciiUnCompress==Fetch)) ||
  582.                     (( ICmappings==nil) && (newPrefsType.AsciiCompress==UseICinComp)) ||
  583.                     (( ICmappings==nil) && (newPrefsType.AsciiUnCompress==UseICinExp))
  584.                     )
  585.                     
  586.                 {
  587.                     Calert("You must restart MacGzip for your changes to take effect");
  588.                 }
  589.                 break;
  590.                 
  591.             case kCancelButtonItem:
  592.                 /* abandon the new preferences structure */
  593.                 doneFlag = true;
  594.                 break;
  595.                 
  596.             case kForce:
  597.             
  598.                 newPrefsType.force = !newPrefsType.force;
  599.                 GetDItem(prefDialogPtr, kForce, &itemType, &itemHandle, &itemRect);
  600.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.force ? 1 : 0));
  601.                 break;
  602.                 
  603.             case kUpArrow:
  604.             
  605.                 if ( newPrefsType.level < 9 )
  606.                 {
  607.                     newPrefsType.level++;
  608.                     GetDItem(prefDialogPtr,kUpArrow, &itemType, &itemHandle, &itemRect);
  609.                     InvertRect(&itemRect);
  610.                     while (StillDown())
  611.                     ;
  612.                     InvertRect(&itemRect);
  613.                     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  614.                     NumToString( (long)newPrefsType.level, sTemp );
  615.                     SetIText(itemHandle,sTemp);
  616.                 }
  617.                 break;
  618.                 
  619.             case kDownArrow:
  620.             
  621.                 if ( newPrefsType.level > 1 )
  622.                 {
  623.                     newPrefsType.level--;
  624.                     GetDItem(prefDialogPtr,kDownArrow, &itemType, &itemHandle, &itemRect);
  625.                     InvertRect(&itemRect);
  626.                     while (StillDown())
  627.                     ;
  628.                     InvertRect(&itemRect);
  629.                     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  630.                     NumToString( (long)newPrefsType.level, sTemp );
  631.                     SetIText(itemHandle,sTemp);
  632.                 }
  633.                 break;
  634.                 
  635.             case kKeepOrig:
  636.             
  637.                 newPrefsType.KeepOriginals = !newPrefsType.KeepOriginals;
  638.                 GetDItem(prefDialogPtr, kKeepOrig, &itemType, &itemHandle, &itemRect);
  639.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.KeepOriginals ? 1 : 0));
  640.                 break;
  641.  
  642.             case kQuitWD:
  643.             
  644.                 newPrefsType.QuitWhenDone = !newPrefsType.QuitWhenDone;
  645.                 GetDItem(prefDialogPtr, kQuitWD, &itemType, &itemHandle, &itemRect);
  646.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.QuitWhenDone ? 1 : 0));
  647.                 break;
  648.                 
  649.             case kBeepWD:
  650.             
  651.                 newPrefsType.BeepWhenDone = !newPrefsType.BeepWhenDone;
  652.                 GetDItem(prefDialogPtr, kBeepWD, &itemType, &itemHandle, &itemRect);
  653.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.BeepWhenDone ? 1 : 0));
  654.                 break;
  655.                 
  656.             case kAsciiGzip:
  657.             case kAsciiGunzip:
  658.             case kGzip:
  659.             
  660.                 DoPopUp(prefDialogPtr, item);
  661.                 break;
  662.             
  663.             case kCStKeys:
  664.             
  665.                 newPrefsType.StKeysComp = !newPrefsType.StKeysComp;
  666.                 GetDItem(prefDialogPtr, kCStKeys, &itemType, &itemHandle, &itemRect);
  667.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysComp ? 1 : 0));
  668.                 break;
  669.                 
  670.             case kUStKeys:
  671.             
  672.                 newPrefsType.StKeysUnComp = !newPrefsType.StKeysUnComp;
  673.                 GetDItem(prefDialogPtr, kUStKeys, &itemType, &itemHandle, &itemRect);
  674.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysUnComp ? 1 : 0));
  675.                 break;
  676.  
  677.             case kAltStKeys:
  678.             
  679.                 newPrefsType.StKeysAlt = !newPrefsType.StKeysAlt;
  680.                 GetDItem(prefDialogPtr, kAltStKeys, &itemType, &itemHandle, &itemRect);
  681.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.StKeysAlt ? 1 : 0));
  682.                 break;
  683.  
  684.             case kHelp:
  685.             case kBHelp:
  686.             
  687.                 HMSetBalloons(!HMGetBalloons());
  688.                 GetDItem(prefDialogPtr, kHelp, &itemType, &itemHandle, &itemRect);
  689.                 SetCtlValue((ControlHandle) itemHandle, HMGetBalloons());
  690.                 break;
  691.  
  692.                 
  693.         }
  694.     } while (!doneFlag);
  695.     
  696.     HMSetBalloons(SaveBalloons);
  697.     SetItemMark(PopUp[kAsciiGzip-PopUpBaseItem].Menu,PopUp[kAsciiGzip-PopUpBaseItem].Selection,noMark);
  698.     SetItemMark(PopUp[kAsciiGunzip-PopUpBaseItem].Menu,PopUp[kAsciiGunzip-PopUpBaseItem].Selection,noMark);
  699.     SetItemMark(PopUp[kGzip-PopUpBaseItem].Menu,PopUp[kGzip-PopUpBaseItem].Selection,noMark);
  700.  
  701.     DisposDialog(prefDialogPtr);
  702.     
  703.     SetPort(savePort);
  704.  
  705.     /* if the user clicked Save, return true */
  706.     return (item == kSaveButtonItem);
  707. }
  708.  
  709. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem)
  710. {
  711.     ModalFilterProcPtr theModalProc;
  712.     Boolean returnVal = false;
  713.     char theKey;
  714.     
  715.     if (((myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey)) &&
  716.         (myDialogEvent->modifiers & CmdKeyMask))
  717.     {
  718.         theKey = myDialogEvent->message & charCodeMask;
  719.         switch (theKey)
  720.         {
  721.             case kUpArrowKey:
  722.                             *theDialogItem = kUpArrow;
  723.                             returnVal = true;
  724.                             break;
  725.             case kDownArrowKey:
  726.                             *theDialogItem = kDownArrow;
  727.                             returnVal = true;
  728.                             break;
  729.         }
  730.     }
  731.     
  732.     if (!returnVal)
  733.         if (GetStdFilterProc(&theModalProc) == noErr)
  734.             returnVal=theModalProc(inputDialog, myDialogEvent, theDialogItem);
  735.  
  736.     return(returnVal);
  737. }
  738.  
  739. static ICError ICGetPrefHandle (ICInstance inst, ConstStr255Param key, 
  740.                          ICAttr *attr, Handle *prefh)
  741. {
  742.     ICError    err = noErr;
  743.     long    prefsize = 0;
  744.  
  745.     (*prefh) = 0L;
  746.     err = ICGetPref(inst, key, attr, nil, &prefsize);
  747.     if (err != noErr)    prefsize = 0;
  748.  
  749.     (*prefh) = NewHandle(prefsize);
  750.     err = MemError();
  751.     if (err == noErr) {
  752.         HLock(*prefh);
  753.         err = ICGetPref(inst, key, attr, *(*prefh), &prefsize);
  754.         if (err == icPrefNotFoundErr) {
  755.             attr = 0;
  756.             err = noErr;
  757.         }
  758.         HUnlock(*prefh);
  759.     }
  760.     
  761.     if (err != noErr) {
  762.         if (*prefh) DisposeHandle(*prefh);
  763.         (*prefh) = nil;
  764.     }
  765.     return(err);
  766. }
  767.  
  768.  
  769.  
  770.  
  771.  
  772.  
  773.  
  774.  
  775.